home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update23.zoo / libg++ / src / diffcc
Encoding:
Text File  |  1992-07-20  |  51.2 KB  |  2,106 lines
  1. *** 1.5    1992/06/08 20:42:41
  2. --- Changelo    1992/07/20 22:22:32
  3. ***************
  4. *** 241,243 ****
  5. --- 241,254 ----
  6.       addition of stossc() to streambufs for ATT compatibility.
  7.   
  8.   ---------------------------- Patchlevel 12 -----------------------------------
  9. + 
  10. + all over:
  11. +     sync up with libg++ 2.1.9. lots of bug fixes, more accurate floating
  12. +         point i/o. this is not such a big deal for the atari.
  13. + 
  14. + ---------------------------- Patchlevel 12.5 (not released) ------------------
  15. + 
  16. + all over:
  17. +     sync up with libg++ 2.2. very minor bug fixes over libg++ 2.1.9
  18. + 
  19. + ---------------------------- Patchlevel 13 -----------------------------------
  20. *** 1.7    1992/06/08 20:42:41
  21. --- PatchLev.h    1992/07/20 22:22:32
  22. ***************
  23. *** 1,5 ****
  24.   
  25. ! #define    PatchLevel "12"
  26.   
  27.   /*
  28.    *    the Patch Level above is to identify the version
  29. --- 1,5 ----
  30.   
  31. ! #define    PatchLevel "13"
  32.   
  33.   /*
  34.    *    the Patch Level above is to identify the version
  35. *** 1.6    1992/06/08 20:42:41
  36. --- filebuf.cc    1992/07/20 22:22:35
  37. ***************
  38. *** 65,70 ****
  39. --- 65,73 ----
  40.   // UNBUFFERED STREAMS:
  41.   // If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
  42.   
  43. + #define CLOSED_FILEBUF_FLAGS \
  44. +   (_S_IS_FILEBUF+_S_NO_READS+_S_NO_WRITES+_S_TIED_PUT_GET)
  45. + 
  46.   void filebuf::init()
  47.   {
  48.       _fb._offset = 0;
  49. ***************
  50. *** 97,115 ****
  51.   }
  52.   
  53.   
  54. ! filebuf::filebuf() : backupbuf(_S_IS_FILEBUF+_S_NO_READS+_S_NO_WRITES)
  55.   {
  56.       init();
  57.   }
  58.   
  59. ! filebuf::filebuf(int fd) : backupbuf(_S_IS_FILEBUF+_S_NO_READS+_S_NO_WRITES)
  60.   {
  61.       init();
  62.       attach(fd);
  63.   }
  64.   
  65. ! filebuf::filebuf(int fd, char* p, size_t len)
  66. ! : backupbuf(_S_IS_FILEBUF+_S_NO_READS+_S_NO_WRITES)
  67.   {
  68.       init();
  69.       attach(fd);
  70. --- 100,117 ----
  71.   }
  72.   
  73.   
  74. ! filebuf::filebuf() : backupbuf(CLOSED_FILEBUF_FLAGS)
  75.   {
  76.       init();
  77.   }
  78.   
  79. ! filebuf::filebuf(int fd) : backupbuf(CLOSED_FILEBUF_FLAGS)
  80.   {
  81.       init();
  82.       attach(fd);
  83.   }
  84.   
  85. ! filebuf::filebuf(int fd, char* p, size_t len) : backupbuf(CLOSED_FILEBUF_FLAGS)
  86.   {
  87.       init();
  88.       attach(fd);
  89. ***************
  90. *** 139,145 ****
  91.   #endif
  92.       if ((mode & (ios::in|ios::out)) == (ios::in|ios::out)) {
  93.       posix_mode = O_RDWR;
  94. !     read_write = _S_TIED_PUT_GET;
  95.       }
  96.       else if (mode & (ios::out|ios::app))
  97.       posix_mode = O_WRONLY, read_write = _S_NO_READS;
  98. --- 141,147 ----
  99.   #endif
  100.       if ((mode & (ios::in|ios::out)) == (ios::in|ios::out)) {
  101.       posix_mode = O_RDWR;
  102. !     read_write = 0;
  103.       }
  104.       else if (mode & (ios::out|ios::app))
  105.       posix_mode = O_WRONLY, read_write = _S_NO_READS;
  106. ***************
  107. *** 165,173 ****
  108.       else if(mode & (int)ios::text)
  109.       rw_mode &= ~_S_IS_BINARY;
  110.       read_write |= rw_mode;
  111. !     xsetflags(read_write, (_S_NO_READS+_S_NO_WRITES+_S_TIED_PUT_GET)|rw_mode);
  112.   #else
  113. !     xsetflags(read_write, _S_NO_READS+_S_NO_WRITES+_S_TIED_PUT_GET);
  114.   #endif
  115.       if (mode & ios::ate) {
  116.       if (seekoff(0, ios::end) == EOF)
  117. --- 167,175 ----
  118.       else if(mode & (int)ios::text)
  119.       rw_mode &= ~_S_IS_BINARY;
  120.       read_write |= rw_mode;
  121. !     xsetflags(read_write, (_S_NO_READS+_S_NO_WRITES)|rw_mode);
  122.   #else
  123. !     xsetflags(read_write, _S_NO_READS+_S_NO_WRITES);
  124.   #endif
  125.       if (mode & ios::ate) {
  126.       if (seekoff(0, ios::end) == EOF)
  127. ***************
  128. *** 216,222 ****
  129.       }
  130.       if (mode[0] == '+' || (mode[0] == 'b' && mode[1] == '+')) {
  131.       omode = O_RDWR;
  132. !     read_write = _S_TIED_PUT_GET;
  133.       }
  134.       int fdesc = ::open(filename, omode|oflags, oprot);
  135.       if (fdesc < 0)
  136. --- 218,224 ----
  137.       }
  138.       if (mode[0] == '+' || (mode[0] == 'b' && mode[1] == '+')) {
  139.       omode = O_RDWR;
  140. !     read_write = 0;
  141.       }
  142.       int fdesc = ::open(filename, omode|oflags, oprot);
  143.       if (fdesc < 0)
  144. ***************
  145. *** 224,232 ****
  146.       _fb._fileno = fdesc;
  147.   #ifdef atarist
  148.       read_write |= rw_mode;
  149. !     xsetflags(read_write, (_S_NO_READS+_S_NO_WRITES+_S_TIED_PUT_GET)|rw_mode);
  150.   #else
  151. !     xsetflags(read_write, _S_NO_READS+_S_NO_WRITES+_S_TIED_PUT_GET);
  152.   #endif
  153.       _link_in();
  154.       return this;
  155. --- 226,234 ----
  156.       _fb._fileno = fdesc;
  157.   #ifdef atarist
  158.       read_write |= rw_mode;
  159. !     xsetflags(read_write, (_S_NO_READS+_S_NO_WRITES)|rw_mode);
  160.   #else
  161. !     xsetflags(read_write, _S_NO_READS+_S_NO_WRITES);
  162.   #endif
  163.       _link_in();
  164.       return this;
  165. ***************
  166. *** 253,267 ****
  167.       if (xflags() & _S_NO_WRITES) // SET ERROR
  168.       return EOF;
  169.       // Allocate a buffer if needed.
  170. !     if (pbase() == NULL) {
  171. !     if (base() == NULL)
  172. !         doallocbuf();
  173. !     if (xflags() & _S_LINE_BUF+_S_UNBUFFERED) setp(base(), base());
  174. !     else setp(base(), ebuf());
  175. !     setg(pbase(), pbase(), pbase());
  176.       }
  177.       // If currently reading, switch to writing.
  178. !     if ((_flags & _S_TIED_PUT_GET+_S_CURRENTLY_PUTTING) == _S_TIED_PUT_GET) {
  179.       if (xflags() & _S_LINE_BUF+_S_UNBUFFERED) setp(gptr(), gptr());
  180.       else setp(gptr(), ebuf());
  181.       setg(egptr(), egptr(), egptr());
  182. --- 255,269 ----
  183.       if (xflags() & _S_NO_WRITES) // SET ERROR
  184.       return EOF;
  185.       // Allocate a buffer if needed.
  186. !     if (base() == NULL) {
  187. !     doallocbuf();
  188. !     if (xflags() & _S_LINE_BUF+_S_UNBUFFERED) setp(_base, _base);
  189. !     else setp(_base, _ebuf);
  190. !     setg(_base, _base, _base);
  191. !     _flags |= _S_CURRENTLY_PUTTING;
  192.       }
  193.       // If currently reading, switch to writing.
  194. !     else if ((_flags & _S_CURRENTLY_PUTTING) == 0) {
  195.       if (xflags() & _S_LINE_BUF+_S_UNBUFFERED) setp(gptr(), gptr());
  196.       else setp(gptr(), ebuf());
  197.       setg(egptr(), egptr(), egptr());
  198. ***************
  199. *** 269,275 ****
  200.       }
  201.       if (c == EOF)
  202.       return do_flush();
  203. !     if (pptr() == ebuf()) // Buffer is really full
  204.       if (do_flush() == EOF)
  205.           return EOF;
  206.       xput_char(c);
  207. --- 271,277 ----
  208.       }
  209.       if (c == EOF)
  210.       return do_flush();
  211. !     if (pptr() == ebuf() ) // Buffer is really full
  212.       if (do_flush() == EOF)
  213.           return EOF;
  214.       xput_char(c);
  215. ***************
  216. *** 311,316 ****
  217. --- 313,319 ----
  218.           xsetflags(_S_ERR_SEEN), count = 0;
  219.       }
  220.       setg(base(), base(), base() + count);
  221. +     setp(base(), base());
  222.       if (count == 0)
  223.       return EOF;
  224.       if (_fb._offset >= 0)
  225. ***************
  226. *** 318,326 ****
  227.       return *(unsigned char*)gptr();
  228.   }
  229.   
  230. ! int filebuf::do_flush()
  231.   {
  232. -     long to_do = pptr()-pbase();
  233.       if (to_do == 0)
  234.       return 0;
  235.       if (egptr() != pbase()) {
  236. --- 321,328 ----
  237.       return *(unsigned char*)gptr();
  238.   }
  239.   
  240. ! int filebuf::do_write(const char *data, int to_do)
  241.   {
  242.       if (to_do == 0)
  243.       return 0;
  244.       if (egptr() != pbase()) {
  245. ***************
  246. *** 329,337 ****
  247.           return EOF;
  248.       _fb._offset = new_pos;
  249.       }
  250. !     _G_ssize_t count = sys_write(pbase(), to_do);
  251.       if (_cur_column)
  252. !     _cur_column = __adjust_column(_cur_column - 1, pbase(), to_do) + 1;
  253.       if (count != to_do)
  254.       return EOF;
  255.       setg(base(), base(), base());
  256. --- 331,339 ----
  257.           return EOF;
  258.       _fb._offset = new_pos;
  259.       }
  260. !     _G_ssize_t count = sys_write(data, to_do);
  261.       if (_cur_column)
  262. !     _cur_column = __adjust_column(_cur_column - 1, data, to_do) + 1;
  263.       if (count != to_do)
  264.       return EOF;
  265.       setg(base(), base(), base());
  266. ***************
  267. *** 377,384 ****
  268.       if (pptr() > pbase() || put_mode())
  269.       if (switch_to_get_mode()) return EOF;
  270.   
  271. !     allocbuf();
  272. !     // FIXME:  Will this work if get and put areas are NULL?
  273.       switch (dir) {
  274.         case ios::cur:
  275.       if (_fb._offset < 0) {
  276. --- 379,389 ----
  277.       if (pptr() > pbase() || put_mode())
  278.       if (switch_to_get_mode()) return EOF;
  279.   
  280. !     if (base() == NULL) {
  281. !     doallocbuf();
  282. !     setp(base(), base());
  283. !     setg(base(), base(), base());
  284. !     }
  285.       switch (dir) {
  286.         case ios::cur:
  287.       if (_fb._offset < 0) {
  288. ***************
  289. *** 460,465 ****
  290. --- 465,471 ----
  291.       }
  292.       }
  293.       setg(base(), base()+delta, base()+count);
  294. +     setp(base(), base());
  295.       _fb._offset = result + count;
  296.       xflags(xflags() & ~ _S_EOF_SEEN);
  297.       return offset;
  298. ***************
  299. *** 494,500 ****
  300.       setp(NULL, NULL);
  301.   
  302.       _un_link();
  303. !     _flags = _IO_MAGIC | _S_IS_FILEBUF | _S_NO_READS | _S_NO_WRITES;
  304.       _fb._fileno = EOF;
  305.       _fb._offset = 0;
  306.   
  307. --- 500,506 ----
  308.       setp(NULL, NULL);
  309.   
  310.       _un_link();
  311. !     _flags = _IO_MAGIC|CLOSED_FILEBUF_FLAGS;
  312.       _fb._fileno = EOF;
  313.       _fb._offset = 0;
  314.   
  315. ***************
  316. *** 503,509 ****
  317.   
  318.   _G_ssize_t filebuf::sys_read(char* buf, size_t size)
  319.   {
  320. !     return ::read(_fb._fileno, buf, size);
  321.   }
  322.   
  323.   fpos_t filebuf::sys_seek(fpos_t offset, _seek_dir dir)
  324. --- 509,519 ----
  325.   
  326.   _G_ssize_t filebuf::sys_read(char* buf, size_t size)
  327.   {
  328. !     for (;;) {
  329. !     _G_ssize_t count = ::read(_fb._fileno, buf, size);
  330. !     if (count != -1 || errno != EINTR)
  331. !         return count;
  332. !     }
  333.   }
  334.   
  335.   fpos_t filebuf::sys_seek(fpos_t offset, _seek_dir dir)
  336. ***************
  337. *** 516,523 ****
  338.       long to_do = n;
  339.       while (to_do > 0) {
  340.       _G_ssize_t count = ::write(fd(), buf, to_do);
  341. !     if (count == EOF)
  342. !         break;
  343.       to_do -= count;
  344.       buf += count;
  345.       }
  346. --- 526,537 ----
  347.       long to_do = n;
  348.       while (to_do > 0) {
  349.       _G_ssize_t count = ::write(fd(), buf, to_do);
  350. !     if (count == EOF) {
  351. !         if (errno == EINTR)
  352. !         continue;
  353. !         else
  354. !         break;
  355. !     }
  356.       to_do -= count;
  357.       buf += count;
  358.       }
  359. ***************
  360. *** 539,544 ****
  361. --- 553,560 ----
  362.   
  363.   size_t filebuf::sputn(const char *s, size_t n)
  364.   {
  365. +     if (n <= 0)
  366. +     return 0;
  367.       // This is an optimized implementation.
  368.       // If the amount to be written straddles a block boundary
  369.       // (or the filebuf is unbuffered), use sys_write directly.
  370. ***************
  371. *** 567,599 ****
  372.   
  373.       // Try to maintain alignment: write a whole number of blocks.
  374.       // dont_write is what gets left over.
  375. !     int block_size = _epptr - _pbase;
  376.       int dont_write = block_size >= 128 ? to_do % block_size : 0;
  377.   
  378. !     _G_ssize_t written = sys_write(s, to_do - dont_write);
  379. !     if (_cur_column)
  380. !         _cur_column = 1 + __adjust_column(_cur_column - 1,
  381. !                           s, to_do-dont_write);
  382. ! 
  383. !     s += written;
  384. !     to_do -= written;
  385. !     if (to_do != dont_write)
  386.           return n - to_do;
  387.   
  388. !     count = _epptr - _pptr; // Space available.
  389. !     // Write out the remainder, if any.
  390. !     if (count > to_do)
  391. !         count = to_do;
  392. !     if (count > 20) {
  393. !         memcpy(pptr(), s, count);
  394. !         s += count;
  395. !     }
  396. !     else {
  397. !         register char *p = pptr();;
  398. !         for (register int i = count; --i >= 0; ) *p++ = *s++;
  399. !     }
  400. !     pbump(count);
  401. !     to_do -= count;
  402.       }
  403.       return n - to_do;
  404.   }
  405. --- 583,601 ----
  406.   
  407.       // Try to maintain alignment: write a whole number of blocks.
  408.       // dont_write is what gets left over.
  409. !     int block_size = _ebuf - _base;
  410.       int dont_write = block_size >= 128 ? to_do % block_size : 0;
  411.   
  412. !     _G_ssize_t count = to_do - dont_write;
  413. !     if (do_write(s, count) == EOF)
  414.           return n - to_do;
  415. +     to_do = dont_write;
  416.   
  417. !     // Now write out the remainder.  Normally, this will fit in the
  418. !     // buffer, but it's somewhat messier for line-buffered files,
  419. !     // so we let streambuf::sputn handle the general case.
  420. !     if (dont_write)
  421. !         to_do -= streambuf::sputn(s+count, dont_write);
  422.       }
  423.       return n - to_do;
  424.   }
  425. *** 1.2    1992/06/03 02:12:17
  426. --- fstream.cc    1992/07/20 22:22:35
  427. ***************
  428. *** 37,43 ****
  429.       _strbuf = new filebuf();
  430.       if (!rdbuf()->open(name, mode, prot))
  431.       set(ios::badbit);
  432. -     _flags &= ~ios::dont_close;
  433.   }
  434.   
  435.   ofstream::ofstream()
  436. --- 37,42 ----
  437. ***************
  438. *** 55,61 ****
  439.       _strbuf = new filebuf();
  440.       if (!rdbuf()->open(name, mode, prot))
  441.       set(ios::badbit);
  442. -     _flags &= ~ios::dont_close;
  443.   }
  444.   
  445.   #if 0
  446. --- 54,59 ----
  447. ***************
  448. *** 107,113 ****
  449.       _strbuf = new filebuf();
  450.       if (!rdbuf()->open(name, mode, prot))
  451.       set(ios::badbit);
  452. -     _flags &= ~ios::dont_close;
  453.   }
  454.   
  455.   void fstream::open(const char *name, int mode, int prot=0664)
  456. --- 105,110 ----
  457. *** 1.1    1992/03/22 07:42:32
  458. --- gnuaux.c    1992/07/20 22:22:35
  459. ***************
  460. *** 83,93 ****
  461.     return __set_new_handler (handler);
  462.   }
  463.   
  464.   static void
  465.   default_new_handler ()
  466.   {
  467.     /* don't use fprintf (stderr, ...) because it may need to call malloc.  */
  468. !   write (2, "default_new_handler: out of memory... aaaiiiiiieeeeeeeeeeeeee!\n", 65);
  469.     /* don't call exit () because that may call global destructors which
  470.        may cause a loop.  */
  471.     _exit (-1);
  472. --- 83,94 ----
  473.     return __set_new_handler (handler);
  474.   }
  475.   
  476. + #define MESSAGE "default_new_handler: out of memory... aaaiiiiiieeeeeeeeeeeeee!\n"
  477.   static void
  478.   default_new_handler ()
  479.   {
  480.     /* don't use fprintf (stderr, ...) because it may need to call malloc.  */
  481. !   _write (2, MESSAGE, sizeof(MESSAGE));
  482.     /* don't call exit () because that may call global destructors which
  483.        may cause a loop.  */
  484.     _exit (-1);
  485. *** 1.2    1992/06/03 02:12:17
  486. --- igetline.cc    1992/07/20 22:22:36
  487. ***************
  488. *** 80,88 ****
  489.       long old_total = total;
  490.       total += count;
  491.       if (ch != EOF && ch != terminator) {
  492.       ptr = _sb_readline(sb, total, terminator);
  493. !     if (ptr)
  494.           memcpy(ptr + old_total, buf, count);
  495.       return ptr;
  496.       }
  497.       
  498. --- 80,91 ----
  499.       long old_total = total;
  500.       total += count;
  501.       if (ch != EOF && ch != terminator) {
  502. +     total++; // Include ch in total.
  503.       ptr = _sb_readline(sb, total, terminator);
  504. !     if (ptr) {
  505.           memcpy(ptr + old_total, buf, count);
  506. +         ptr[old_total+count] = ch;
  507. +     }
  508.       return ptr;
  509.       }
  510.       
  511. *** 1.6    1992/06/08 20:42:41
  512. --- iostream.cc    1992/07/20 22:22:37
  513. ***************
  514. *** 31,58 ****
  515.   
  516.   extern backupbuf not_open_filebuf;
  517.   
  518. ! istream::istream() : ios(¬_open_filebuf)
  519.   {
  520.       _flags |= ios::dont_close;
  521.       _gcount = 0;
  522. -     _tie = NULL;
  523.   }
  524.   
  525. - istream::istream(streambuf *sb, ostream* tied) : ios(sb)
  526. - {
  527. -     _flags |= ios::dont_close;
  528. -     _gcount = 0;
  529. -     _tie = tied;
  530. - }
  531. - 
  532. - istream::~istream()
  533. - {
  534. -     if (!(_flags & (unsigned int)ios::dont_close))
  535. -     delete _strbuf;
  536. -     _flags |= ios::dont_close;
  537. -     _strbuf = ¬_open_filebuf;
  538. - }
  539. - 
  540.   int skip_ws(streambuf* sb)
  541.   {
  542.       int ch;
  543. --- 31,42 ----
  544.   
  545.   extern backupbuf not_open_filebuf;
  546.   
  547. ! istream::istream(streambuf *sb, ostream* tied) : ios(sb, tied)
  548.   {
  549.       _flags |= ios::dont_close;
  550.       _gcount = 0;
  551.   }
  552.   
  553.   int skip_ws(streambuf* sb)
  554.   {
  555.       int ch;
  556. ***************
  557. *** 140,146 ****
  558.       if (ipfx0()) {
  559.       va_list ap;
  560.       va_start(ap, format);
  561. !     _strbuf->vscan(format, ap);
  562.       va_end(ap);
  563.       }
  564.       return *this;
  565. --- 124,130 ----
  566.       if (ipfx0()) {
  567.       va_list ap;
  568.       va_start(ap, format);
  569. !     _strbuf->vscan(format, ap, &_state);
  570.       va_end(ap);
  571.       }
  572.       return *this;
  573. ***************
  574. *** 149,155 ****
  575.   istream& istream::vscan(const char *format, _G_va_list args)
  576.   {
  577.       if (ipfx0())
  578. !     _strbuf->vscan(format, args);
  579.       return *this;
  580.   }
  581.   
  582. --- 133,139 ----
  583.   istream& istream::vscan(const char *format, _G_va_list args)
  584.   {
  585.       if (ipfx0())
  586. !     _strbuf->vscan(format, args, &_state);
  587.       return *this;
  588.   }
  589.   
  590. ***************
  591. *** 254,266 ****
  592.           digit = ch - 'a' + 10;
  593.       else
  594.           digit = 999;
  595. !     if (digit >= base)
  596.           if (ndigits == 0)
  597.           goto fail;
  598. !         else {
  599. !         sb->sputbackc(ch);
  600.           return 1;
  601. !         }
  602.       ndigits++;
  603.       val = base * val + digit;
  604.       ch = sb->sbumpc();
  605. --- 238,250 ----
  606.           digit = ch - 'a' + 10;
  607.       else
  608.           digit = 999;
  609. !     if (digit >= base) {
  610. !         sb->sputbackc(ch);
  611.           if (ndigits == 0)
  612.           goto fail;
  613. !         else
  614.           return 1;
  615. !     }
  616.       ndigits++;
  617.       val = base * val + digit;
  618.       ch = sb->sbumpc();
  619. ***************
  620. *** 369,375 ****
  621.       int buf_len = strlen(buf);
  622.       int w = stream.width(0);
  623.       int show_pos = 0;
  624. -     int i;
  625.   
  626.       // Calculate padding.
  627.       int len = buf_len;
  628. --- 353,358 ----
  629. ***************
  630. *** 380,400 ****
  631.   
  632.       // Do actual output.
  633.       register streambuf* sbuf = stream.rdbuf();
  634. !     unsigned long pad_kind =
  635.       stream.flags() & (ios::left|ios::right|ios::internal);
  636.       char fill_char = stream.fill();
  637. !     if (pad_kind != (unsigned long)ios::left // Default (right) adjustment.
  638. !     && pad_kind != (unsigned long)ios::internal)
  639. !     for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  640.       if (neg) sbuf->sputc('-');
  641.       else if (show_pos) sbuf->sputc('+');
  642.       if (show_base_len)
  643.       sbuf->sputn(show_base, show_base_len);
  644. !     if (pad_kind == (unsigned long)ios::internal)
  645. !     for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  646.       sbuf->sputn(buf, buf_len);
  647. !     if (pad_kind == (unsigned long)ios::left) // Left adjustment.
  648. !     for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  649.       stream.osfx();
  650.   }
  651.   
  652. --- 363,384 ----
  653.   
  654.       // Do actual output.
  655.       register streambuf* sbuf = stream.rdbuf();
  656. !     ios::fmtflags pad_kind =
  657.       stream.flags() & (ios::left|ios::right|ios::internal);
  658.       char fill_char = stream.fill();
  659. !     if (padding > 0
  660. !     && pad_kind != (ios::fmtflags)ios::left
  661. !     && pad_kind != (ios::fmtflags)ios::internal) // Default (right) adjust.
  662. !     sbuf->padn(fill_char, padding);
  663.       if (neg) sbuf->sputc('-');
  664.       else if (show_pos) sbuf->sputc('+');
  665.       if (show_base_len)
  666.       sbuf->sputn(show_base, show_base_len);
  667. !     if (pad_kind == (ios::fmtflags)ios::internal && padding > 0)
  668. !     sbuf->padn(fill_char, padding);
  669.       sbuf->sputn(buf, buf_len);
  670. !     if (pad_kind == (ios::fmtflags)ios::left && padding > 0) // Left adjustment
  671. !     sbuf->padn(fill_char, padding);
  672.       stream.osfx();
  673.   }
  674.   
  675. ***************
  676. *** 445,454 ****
  677.       // Uses __cvt_double (renamed from static cvt), in Chris Torek's
  678.       // stdio implementation.  The setup code uses the same logic
  679.       // as in __vsbprintf.C (also based on Torek's code).
  680. -     char negative;
  681. -     char buf[BUF];
  682.       int format_char;
  683. -     int sign = '\0';
  684.   #if 0
  685.       if (os.flags() ios::showpos) sign = '+';
  686.   #endif
  687. --- 429,435 ----
  688. ***************
  689. *** 469,474 ****
  690. --- 450,463 ----
  691.       }
  692.   
  693.       // Do actual conversion.
  694. + #ifdef USE_DTOA
  695. +     if (__outfloat(n, os.rdbuf(), format_char, os.width(0),
  696. +                os.precision(), os.flags(), 0, os.fill()) < 0)
  697. +         os.set(ios::badbit|ios::failbit); // ??
  698. + #else
  699. +     int negative;
  700. +     char buf[BUF];
  701. +     int sign = '\0';
  702.       char *cp = buf;
  703.       *cp = 0;
  704.       int size = __cvt_double(n, os.precision(),
  705. ***************
  706. *** 491,504 ****
  707.       register streambuf* sbuf = os.rdbuf();
  708.       register i;
  709.       char fill_char = os.fill();
  710. !     unsigned long pad_kind =
  711.           os.flags() & (ios::left|ios::right|ios::internal);
  712. !     if (pad_kind != (unsigned long)ios::left // Default (right) adjust.
  713. !         && pad_kind != (unsigned long)ios::internal)
  714.           for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  715.       if (sign)
  716.           sbuf->sputc(sign);
  717. !     if (pad_kind == (unsigned long)ios::internal)
  718.           for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  719.       
  720.       // Emit the actual concented field, followed by extra zeros.
  721. --- 480,493 ----
  722.       register streambuf* sbuf = os.rdbuf();
  723.       register i;
  724.       char fill_char = os.fill();
  725. !     ios::fmtflags pad_kind =
  726.           os.flags() & (ios::left|ios::right|ios::internal);
  727. !     if (pad_kind != (ios::fmtflags)ios::left // Default (right) adjust.
  728. !         && pad_kind != (ios::fmtflags)ios::internal)
  729.           for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  730.       if (sign)
  731.           sbuf->sputc(sign);
  732. !     if (pad_kind == (ios::fmtflags)ios::internal)
  733.           for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  734.       
  735.       // Emit the actual concented field, followed by extra zeros.
  736. ***************
  737. *** 505,512 ****
  738.       sbuf->sputn(cp, size);
  739.       for (i = fpprec; --i >= 0; ) sbuf->sputc('0');
  740.   
  741. !     if (pad_kind == (unsigned long)ios::left) // Left adjustment
  742.           for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  743.       os.osfx();
  744.       }
  745.       return os;
  746. --- 494,502 ----
  747.       sbuf->sputn(cp, size);
  748.       for (i = fpprec; --i >= 0; ) sbuf->sputc('0');
  749.   
  750. !     if (pad_kind == (ios::fmtflags)ios::left) // Left adjustment
  751.           for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  752. + #endif
  753.       os.osfx();
  754.       }
  755.       return os;
  756. ***************
  757. *** 557,580 ****
  758.       return os;
  759.   }
  760.   
  761. ! ostream::ostream() : ios(¬_open_filebuf)
  762. ! {
  763. !     _flags |= ios::dont_close;
  764. !     _tie = NULL;
  765. ! }
  766. ! 
  767. ! ostream::ostream(streambuf* sb, ostream* tied) : ios(sb)
  768. ! {
  769. !     _flags |= ios::dont_close;
  770. !     _tie = tied;
  771. ! }
  772. ! 
  773. ! ostream::~ostream()
  774.   {
  775. -     if (!(_flags & (unsigned int)ios::dont_close))
  776. -     delete _strbuf;
  777.       _flags |= ios::dont_close;
  778. -     _strbuf = ¬_open_filebuf;
  779.   }
  780.   
  781.   ostream& ostream::seekp(streampos pos)
  782. --- 547,555 ----
  783.       return os;
  784.   }
  785.   
  786. ! ostream::ostream(streambuf* sb, ostream* tied) : ios(sb, tied)
  787.   {
  788.       _flags |= ios::dont_close;
  789.   }
  790.   
  791.   ostream& ostream::seekp(streampos pos)
  792. ***************
  793. *** 696,720 ****
  794.   const unsigned long ios::adjustfield =
  795.       ios::left|ios::right|ios::internal;
  796.   
  797. ! iostream::iostream() : ios(¬_open_filebuf)
  798.   {
  799.       _flags |= ios::dont_close;
  800.       _gcount = 0;
  801. -     _tie = NULL;
  802. - }
  803. - 
  804. - iostream::iostream(streambuf* sb, ostream* tied) : ios(sb)
  805. - {
  806. -     _flags |= ios::dont_close;
  807. -     _tie = tied;
  808. - }
  809. - 
  810. - iostream::~iostream()
  811. - {
  812. -     if (!(_flags & (unsigned int)ios::dont_close))
  813. -     delete _strbuf;
  814. -     _flags |= ios::dont_close;
  815. -     _strbuf = ¬_open_filebuf;
  816.   }
  817.   
  818.   ostream& iostream::form(const char *format ...) // Copy of ostream::form.
  819. --- 671,680 ----
  820.   const unsigned long ios::adjustfield =
  821.       ios::left|ios::right|ios::internal;
  822.   
  823. ! iostream::iostream(streambuf* sb, ostream* tied) : ios(sb, tied)
  824.   {
  825.       _flags |= ios::dont_close;
  826.       _gcount = 0;
  827.   }
  828.   
  829.   ostream& iostream::form(const char *format ...) // Copy of ostream::form.
  830. ***************
  831. *** 730,736 ****
  832.       if (ipfx0()) {
  833.       va_list ap;
  834.       va_start(ap, format);
  835. !     _strbuf->vscan(format, ap);
  836.       va_end(ap);
  837.       }
  838.       return *this;
  839. --- 690,696 ----
  840.       if (ipfx0()) {
  841.       va_list ap;
  842.       va_start(ap, format);
  843. !     _strbuf->vscan(format, ap, &_state);
  844.       va_end(ap);
  845.       }
  846.       return *this;
  847. *** 1.5    1992/06/03 02:12:17
  848. --- mincl    1992/07/20 22:22:38
  849. ***************
  850. *** 18,24 ****
  851.   IOSRC = editbuf.cc filebuf.cc fstream.cc igetline.cc indstrea.cc iostream.cc \
  852.   makebuf.cc parsestr.cc sbufvfor.cc sbufvsca.cc sgetline.cc stdstrbu.cc \
  853.   stdstrea.cc stream.cc streambu.cc strstrea.cc xplotfil.cc xsfile.cc \
  854. ! igetsb.cc
  855.   
  856.   #
  857.   # NOTE:: dummy.o MUST be the last object on this list. otherwise you'll
  858. --- 18,24 ----
  859.   IOSRC = editbuf.cc filebuf.cc fstream.cc igetline.cc indstrea.cc iostream.cc \
  860.   makebuf.cc parsestr.cc sbufvfor.cc sbufvsca.cc sgetline.cc stdstrbu.cc \
  861.   stdstrea.cc stream.cc streambu.cc strstrea.cc xplotfil.cc xsfile.cc \
  862. ! igetsb.cc iodtoa.cc outfloat.cc
  863.   
  864.   #
  865.   # NOTE:: dummy.o MUST be the last object on this list. otherwise you'll
  866. *** 1.2    1992/06/03 02:12:17
  867. --- parsestr.cc    1992/07/20 22:22:39
  868. ***************
  869. *** 292,298 ****
  870.   {
  871.   #if 1
  872.       abort();
  873. !     return 0; // fake the compiler
  874.   #else
  875.       if (i > 0) {
  876.       size_t len = line_length();
  877. --- 292,298 ----
  878.   {
  879.   #if 1
  880.       abort();
  881. !     return 0; // Suppress warning.
  882.   #else
  883.       if (i > 0) {
  884.       size_t len = line_length();
  885. *** 1.5    1992/06/08 20:42:41
  886. --- regex.cc    1992/07/20 22:22:39
  887. ***************
  888. *** 287,293 ****
  889.      necessary.  */
  890.   #define PATFETCH(c)                            \
  891.     {if (p == pend) goto end_of_pattern;                    \
  892. !   c = * (unsigned char *) p++;                        \
  893.     if (translate) c = translate[c]; }
  894.   
  895.   /* Fetch the next character in the uncompiled pattern, with no
  896. --- 287,293 ----
  897.      necessary.  */
  898.   #define PATFETCH(c)                            \
  899.     {if (p == pend) goto end_of_pattern;                    \
  900. !   c = * (const unsigned char *) p++;                        \
  901.     if (translate) c = translate[c]; }
  902.   
  903.   /* Fetch the next character in the uncompiled pattern, with no
  904. ***************
  905. *** 294,300 ****
  906.      translation.  */
  907.   #define PATFETCH_RAW(c)                            \
  908.    {if (p == pend) goto end_of_pattern;                    \
  909. !   c = * (unsigned char *) p++; }
  910.   
  911.   #define PATUNFETCH p--
  912.   
  913. --- 294,300 ----
  914.      translation.  */
  915.   #define PATFETCH_RAW(c)                            \
  916.    {if (p == pend) goto end_of_pattern;                    \
  917. !   c = * (const unsigned char *) p++; }
  918.   
  919.   #define PATUNFETCH p--
  920.   
  921. ***************
  922. *** 385,394 ****
  923.   re_compile_pattern (const char *pattern, int size, struct re_pattern_buffer *bufp)
  924.   {
  925.     register char *b = bufp->buffer;
  926. !   register char *p = pattern;
  927. !   char *pend = pattern + size;
  928.     register unsigned c, c1;
  929. !   char *p1;
  930.     unsigned char *translate = (unsigned char *) bufp->translate;
  931.   
  932.     /* Address of the count-byte of the most recently inserted `exactn'
  933. --- 385,394 ----
  934.   re_compile_pattern (const char *pattern, int size, struct re_pattern_buffer *bufp)
  935.   {
  936.     register char *b = bufp->buffer;
  937. !   register const char *p = pattern;
  938. !   const char *pend = pattern + size;
  939.     register unsigned c, c1;
  940. !   const char *p1;
  941.     unsigned char *translate = (unsigned char *) bufp->translate;
  942.   
  943.     /* Address of the count-byte of the most recently inserted `exactn'
  944. ***************
  945. *** 429,435 ****
  946.   
  947.     /* Place in pattern (i.e., the {) to which to go back if the interval
  948.        is invalid.  */
  949. !   char *beg_interval = 0;
  950.     
  951.     /* Stack of information saved by \( and restored by \).
  952.        Four stack elements are pushed by each \(:
  953. --- 429,435 ----
  954.   
  955.     /* Place in pattern (i.e., the {) to which to go back if the interval
  956.        is invalid.  */
  957. !   const char *beg_interval = 0;
  958.     
  959.     /* Stack of information saved by \( and restored by \).
  960.        Four stack elements are pushed by each \(:
  961. ***************
  962. *** 479,485 ****
  963.       {
  964.       case '$':
  965.         {
  966. !         char *p1 = p;
  967.           /* When testing what follows the $,
  968.              look past the \-constructs that don't consume anything.  */
  969.           if (! (obscure_syntax & RE_CONTEXT_INDEP_OPS))
  970. --- 479,485 ----
  971.       {
  972.       case '$':
  973.         {
  974. !         const char *p1 = p;
  975.           /* When testing what follows the $,
  976.              look past the \-constructs that don't consume anything.  */
  977.           if (! (obscure_syntax & RE_CONTEXT_INDEP_OPS))
  978. *** 1.4    1992/06/03 02:12:17
  979. --- sbufvfor.cc    1992/07/20 22:22:39
  980. ***************
  981. *** 123,132 ****
  982.   
  983.   int streambuf::vform(char const *fmt0, _G_va_list ap)
  984.   {
  985. !     register char *fmt;    /* format string */
  986.       register int ch;    /* character from fmt */
  987.       register int n;        /* handy integer (short term usage) */
  988.       register char *cp;    /* handy char pointer (short term usage) */
  989.       register int flags;    /* flags as above */
  990.       int ret;        /* return value accumulator */
  991.       int width;        /* width from format (%8d), or 0 */
  992. --- 123,133 ----
  993.   
  994.   int streambuf::vform(char const *fmt0, _G_va_list ap)
  995.   {
  996. !     register const char *fmt; /* format string */
  997.       register int ch;    /* character from fmt */
  998.       register int n;        /* handy integer (short term usage) */
  999.       register char *cp;    /* handy char pointer (short term usage) */
  1000. +     const char *fmark;    /* for remembering a place in fmt */
  1001.       register int flags;    /* flags as above */
  1002.       int ret;        /* return value accumulator */
  1003.       int width;        /* width from format (%8d), or 0 */
  1004. ***************
  1005. *** 133,139 ****
  1006.       int prec;        /* precision from format (%.3d), or -1 */
  1007.       char sign;        /* sign prefix (' ', '+', '-', or \0) */
  1008.   #ifdef FLOATING_POINT
  1009. !     char softsign;        /* temporary negative sign for floats */
  1010.       double _double;        /* double precision arguments %[eEfgG] */
  1011.       int fpprec;        /* `extra' floating precision in [eEfgG] */
  1012.   #endif
  1013. --- 134,140 ----
  1014.       int prec;        /* precision from format (%.3d), or -1 */
  1015.       char sign;        /* sign prefix (' ', '+', '-', or \0) */
  1016.   #ifdef FLOATING_POINT
  1017. !     int softsign;        /* temporary negative sign for floats */
  1018.       double _double;        /* double precision arguments %[eEfgG] */
  1019.       int fpprec;        /* `extra' floating precision in [eEfgG] */
  1020.   #endif
  1021. ***************
  1022. *** 166,171 ****
  1023. --- 167,176 ----
  1024.   #define    PRINT(ptr, len) \
  1025.     do { if (sputn(ptr, len) != len) goto error; } while (0)
  1026.   #define    FLUSH() { }
  1027. + #if 1
  1028. + #define PAD_SP(howmany) if (padn(' ', howmany) < 0) goto error;
  1029. + #define PAD_0(howmany) if (padn('0', howmany) < 0) goto error;
  1030. + #else
  1031.   #define    PAD(howmany, with) { \
  1032.       if ((n = (howmany)) > 0) { \
  1033.           while (n > PADSIZE) { \
  1034. ***************
  1035. *** 175,180 ****
  1036. --- 180,188 ----
  1037.           PRINT(with, n); \
  1038.       } \
  1039.   }
  1040. + #define PAD_SP(howmany) PAD(howmany, blanks)
  1041. + #define PAD_0(howmany) PAD(howmany, zeroes)
  1042. + #endif
  1043.   
  1044.       /*
  1045.        * To extend shorts properly, we need both signed and unsigned
  1046. ***************
  1047. *** 193,199 ****
  1048.       if (unbuffered())
  1049.           return help_vform(this, fmt0, ap);
  1050.   
  1051. !     fmt = (char *)fmt0;
  1052.       ret = 0;
  1053.   
  1054.       /*
  1055. --- 201,207 ----
  1056.       if (unbuffered())
  1057.           return help_vform(this, fmt0, ap);
  1058.   
  1059. !     fmt = fmt0;
  1060.       ret = 0;
  1061.   
  1062.       /*
  1063. ***************
  1064. *** 200,209 ****
  1065.        * Scan the format for conversions (`%' character).
  1066.        */
  1067.       for (;;) {
  1068. !         for (cp = fmt; (ch = *fmt) != '\0' && ch != '%'; fmt++)
  1069.               /* void */;
  1070. !         if ((n = fmt - cp) != 0) {
  1071. !             PRINT(cp, n);
  1072.               ret += n;
  1073.           }
  1074.           if (ch == '\0')
  1075. --- 208,217 ----
  1076.        * Scan the format for conversions (`%' character).
  1077.        */
  1078.       for (;;) {
  1079. !         for (fmark = fmt; (ch = *fmt) != '\0' && ch != '%'; fmt++)
  1080.               /* void */;
  1081. !         if ((n = fmt - fmark) != 0) {
  1082. !             PRINT(fmark, n);
  1083.               ret += n;
  1084.           }
  1085.           if (ch == '\0')
  1086. ***************
  1087. *** 312,320 ****
  1088. --- 320,346 ----
  1089.           case 'e':
  1090.           case 'E':
  1091.           case 'f':
  1092. +         case 'F':
  1093.           case 'g':
  1094.           case 'G':
  1095.               _double = va_arg(ap, double);
  1096. + #ifdef USE_DTOA
  1097. +             {
  1098. +                 ios::fmtflags fmt_flags = 0;
  1099. +                 if (flags & ALT)
  1100. +                 fmt_flags |= ios::showpoint;
  1101. +                 if (flags & LADJUST)
  1102. +                 fmt_flags |= ios::right;
  1103. +                 if (__outfloat(_double, this, ch, width,
  1104. +                        prec < 0 ? DEFPREC : prec,
  1105. +                        fmt_flags,
  1106. +                        sign,
  1107. +                        flags & ZEROPAD ? '0' : ' ') < 0)
  1108. +                 goto error;
  1109. +             }
  1110. +             // CHECK ERROR!
  1111. +             continue;
  1112. + #else
  1113.               /*
  1114.                * don't do unrealistic precision; just pad it with
  1115.                * zeroes later, so buffer size stays rational.
  1116. ***************
  1117. *** 340,345 ****
  1118. --- 366,372 ----
  1119.               if (*cp == '\0')
  1120.                   cp++;
  1121.               break;
  1122. + #endif
  1123.   #endif /* FLOATING_POINT */
  1124.           case 'n':
  1125.               if (flags & LONGINT)
  1126. ***************
  1127. *** 510,516 ****
  1128.   
  1129.           /* right-adjusting blank padding */
  1130.           if ((flags & (LADJUST|ZEROPAD)) == 0)
  1131. !             PAD(width - realsz, blanks);
  1132.   
  1133.           /* prefix */
  1134.           if (sign) {
  1135. --- 537,543 ----
  1136.   
  1137.           /* right-adjusting blank padding */
  1138.           if ((flags & (LADJUST|ZEROPAD)) == 0)
  1139. !             PAD_SP(width - realsz);
  1140.   
  1141.           /* prefix */
  1142.           if (sign) {
  1143. ***************
  1144. *** 523,532 ****
  1145.   
  1146.           /* right-adjusting zero padding */
  1147.           if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
  1148. !             PAD(width - realsz, zeroes);
  1149.   
  1150.           /* leading zeroes from decimal precision */
  1151. !         PAD(dprec - fieldsz, zeroes);
  1152.   
  1153.           /* the string or number proper */
  1154.           PRINT(cp, size);
  1155. --- 550,559 ----
  1156.   
  1157.           /* right-adjusting zero padding */
  1158.           if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
  1159. !             PAD_0(width - realsz);
  1160.   
  1161.           /* leading zeroes from decimal precision */
  1162. !         PAD_0(dprec - fieldsz);
  1163.   
  1164.           /* the string or number proper */
  1165.           PRINT(cp, size);
  1166. ***************
  1167. *** 533,544 ****
  1168.   
  1169.   #ifdef FLOATING_POINT
  1170.           /* trailing f.p. zeroes */
  1171. !         PAD(fpprec, zeroes);
  1172.   #endif
  1173.   
  1174.           /* left-adjusting padding (always blank) */
  1175.           if (flags & LADJUST)
  1176. !             PAD(width - realsz, blanks);
  1177.   
  1178.           /* finally, adjust ret */
  1179.           ret += width > realsz ? width : realsz;
  1180. --- 560,571 ----
  1181.   
  1182.   #ifdef FLOATING_POINT
  1183.           /* trailing f.p. zeroes */
  1184. !         PAD_0(fpprec);
  1185.   #endif
  1186.   
  1187.           /* left-adjusting padding (always blank) */
  1188.           if (flags & LADJUST)
  1189. !             PAD_SP(width - realsz);
  1190.   
  1191.           /* finally, adjust ret */
  1192.           ret += width > realsz ? width : realsz;
  1193. ***************
  1194. *** 553,559 ****
  1195.       /* NOTREACHED */
  1196.   }
  1197.   
  1198. ! #ifdef FLOATING_POINT
  1199.   
  1200.   static char *exponent(register char *p, register int exp, int fmtch)
  1201.   {
  1202. --- 580,586 ----
  1203.       /* NOTREACHED */
  1204.   }
  1205.   
  1206. ! #if defined(FLOATING_POINT) && !defined(USE_DTOA)
  1207.   
  1208.   static char *exponent(register char *p, register int exp, int fmtch)
  1209.   {
  1210. ***************
  1211. *** 584,590 ****
  1212.   
  1213.   static char * round(double fract, int *exp,
  1214.               register char *start, register char *end,
  1215. !             char ch, char *signp)
  1216.   {
  1217.       double tmp;
  1218.   
  1219. --- 611,617 ----
  1220.   
  1221.   static char * round(double fract, int *exp,
  1222.               register char *start, register char *end,
  1223. !             char ch, int *signp)
  1224.   {
  1225.       double tmp;
  1226.   
  1227. ***************
  1228. *** 624,638 ****
  1229.       return (start);
  1230.   }
  1231.   
  1232. ! int __cvt_double(double number, register int prec, int flags, char *signp,
  1233.            int fmtch, char *startp, char *endp)
  1234.   {
  1235.       register char *p, *t;
  1236.       register double fract;
  1237. !     int dotrim, expcnt, gformat;
  1238.       double integer, tmp;
  1239.   
  1240. !     dotrim = expcnt = gformat = 0;
  1241.       if (number < 0) {
  1242.           number = -number;
  1243.           *signp = '-';
  1244. --- 651,665 ----
  1245.       return (start);
  1246.   }
  1247.   
  1248. ! int __cvt_double(double number, register int prec, int flags, int *signp,
  1249.            int fmtch, char *startp, char *endp)
  1250.   {
  1251.       register char *p, *t;
  1252.       register double fract;
  1253. !     int dotrim = 0, expcnt, gformat = 0;
  1254.       double integer, tmp;
  1255.   
  1256. !     expcnt = 0;
  1257.       if (number < 0) {
  1258.           number = -number;
  1259.           *signp = '-';
  1260. ***************
  1261. *** 654,659 ****
  1262. --- 681,687 ----
  1263.       }
  1264.       switch (fmtch) {
  1265.       case 'f':
  1266. +     case 'F':
  1267.           /* reverse integer into beginning of buffer */
  1268.           if (expcnt)
  1269.               for (; ++p < endp; *t++ = *p);
  1270. ***************
  1271. *** 812,815 ****
  1272.       return (t - startp);
  1273.   }
  1274.   
  1275. ! #endif /* FLOATING_POINT */
  1276. --- 840,843 ----
  1277.       return (t - startp);
  1278.   }
  1279.   
  1280. ! #endif /* defined(FLOATING_POINT) && !defined(USE_DTOA) */
  1281. *** 1.3    1992/06/03 02:12:17
  1282. --- sbufvsca.cc    1992/07/20 22:22:40
  1283. ***************
  1284. *** 82,92 ****
  1285.   #define u_long unsigned long
  1286.   
  1287.   extern "C" u_long strtoul(const char*, char**, int);
  1288. ! static u_char *__sccl(register char *tab, register u_char *fmt);
  1289.   
  1290. ! int streambuf::vscan(char const *fmt0, _G_va_list ap)
  1291.   {
  1292. !     register u_char *fmt = (u_char *)fmt0;
  1293.       register int c;        /* character from format, or conversion */
  1294.       register size_t width;    /* field width, or 0 */
  1295.       register char *p;    /* points into all kinds of strings */
  1296. --- 82,96 ----
  1297.   #define u_long unsigned long
  1298.   
  1299.   extern "C" u_long strtoul(const char*, char**, int);
  1300. ! static const u_char *__sccl(register char *tab, register const u_char *fmt);
  1301.   
  1302. ! // If state is non-NULL, set failbit and/or eofbit as appropriate.
  1303. ! 
  1304. ! int streambuf::vscan(char const *fmt0,
  1305. !              _G_va_list ap,
  1306. !              ios::iostate *state /* = NULL */)
  1307.   {
  1308. !     register const u_char *fmt = (const u_char *)fmt0;
  1309.       register int c;        /* character from format, or conversion */
  1310.       register size_t width;    /* field width, or 0 */
  1311.       register char *p;    /* points into all kinds of strings */
  1312. ***************
  1313. *** 101,106 ****
  1314. --- 105,111 ----
  1315.       // conversion function (strtol/strtoul)
  1316.       char ccltab[256];    /* character class table for %[...] */
  1317.       char buf[BUF];        /* buffer for numeric conversions */
  1318. +     int seen_eof = 0;
  1319.   
  1320.       /* `basefix' is used to avoid `if' tests in the integer scanner */
  1321.       static short basefix[17] =
  1322. ***************
  1323. *** 111,122 ****
  1324.       for (;;) {
  1325.           c = *fmt++;
  1326.           if (c == 0)
  1327. !             return (nassigned);
  1328.           if (isspace(c)) {
  1329.               for (;;) {
  1330.                       c = sbumpc();
  1331.                   if (c == EOF)
  1332. !                     return nassigned;
  1333.                   if (!isspace(c)) {
  1334.                       sputbackc(c);
  1335.                       break;
  1336. --- 116,127 ----
  1337.       for (;;) {
  1338.           c = *fmt++;
  1339.           if (c == 0)
  1340. !             goto done;
  1341.           if (isspace(c)) {
  1342.               for (;;) {
  1343.                       c = sbumpc();
  1344.                   if (c == EOF)
  1345. !                     goto eof_failure;
  1346.                   if (!isspace(c)) {
  1347.                       sputbackc(c);
  1348.                       break;
  1349. ***************
  1350. *** 139,145 ****
  1351.   literal:
  1352.                   n = sbumpc();
  1353.               if (n == EOF)
  1354. !                 goto input_failure;
  1355.               if (n != c) {
  1356.                   sputbackc(n);
  1357.                   goto match_failure;
  1358. --- 144,150 ----
  1359.   literal:
  1360.                   n = sbumpc();
  1361.               if (n == EOF)
  1362. !                 goto eof_failure;
  1363.               if (n != c) {
  1364.                   sputbackc(n);
  1365.                   goto match_failure;
  1366. ***************
  1367. *** 259,265 ****
  1368.            * Disgusting backwards compatibility hacks.    XXX
  1369.            */
  1370.           case '\0':    /* compat */
  1371. !             return (EOF);
  1372.   
  1373.           default:    /* compat */
  1374.               if (isupper(c))
  1375. --- 264,271 ----
  1376.            * Disgusting backwards compatibility hacks.    XXX
  1377.            */
  1378.           case '\0':    /* compat */
  1379. !                 nassigned = EOF;
  1380. !             goto done;
  1381.   
  1382.           default:    /* compat */
  1383.               if (isupper(c))
  1384. ***************
  1385. *** 274,280 ****
  1386.            * We have a conversion that requires input.
  1387.            */
  1388.           if (sgetc() == EOF)
  1389. !             goto input_failure;
  1390.   
  1391.           /*
  1392.            * Consume leading white space, except for formats
  1393. --- 280,286 ----
  1394.            * We have a conversion that requires input.
  1395.            */
  1396.           if (sgetc() == EOF)
  1397. !             goto eof_failure;
  1398.   
  1399.           /*
  1400.            * Consume leading white space, except for formats
  1401. ***************
  1402. *** 287,293 ****
  1403.               nread++;
  1404.               n = sgetc();
  1405.               if (n == EOF)
  1406. !                 goto input_failure;
  1407.               }
  1408.               // Note that there is at least one character in
  1409.               // the buffer, so conversions that do not set NOSKIP
  1410. --- 293,299 ----
  1411.               nread++;
  1412.               n = sgetc();
  1413.               if (n == EOF)
  1414. !                 goto eof_failure;
  1415.               }
  1416.               // Note that there is at least one character in
  1417.               // the buffer, so conversions that do not set NOSKIP
  1418. ***************
  1419. *** 301,307 ****
  1420.   
  1421.           case CT_CHAR:
  1422.               /* scan arbitrary characters (sets NOSKIP) */
  1423. !             if (width == 0)
  1424.                   width = 1;
  1425.               if (flags & SUPPRESS) {
  1426.                   size_t sum = 0;
  1427. --- 307,313 ----
  1428.   
  1429.           case CT_CHAR:
  1430.               /* scan arbitrary characters (sets NOSKIP) */
  1431. !             if (width == 0) // FIXME!
  1432.                   width = 1;
  1433.               if (flags & SUPPRESS) {
  1434.                   size_t sum = 0;
  1435. ***************
  1436. *** 312,320 ****
  1437.                       _gptr += n;
  1438.                       if (underflow() == EOF)
  1439.                       if (sum == 0)
  1440. !                         goto input_failure;
  1441. !                     else
  1442.                           break;
  1443.                   } else {
  1444.                       sum += width;
  1445.                       _gptr += width;
  1446. --- 318,328 ----
  1447.                       _gptr += n;
  1448.                       if (underflow() == EOF)
  1449.                       if (sum == 0)
  1450. !                         goto eof_failure;
  1451. !                     else {
  1452. !                         seen_eof++;
  1453.                           break;
  1454. +                     }
  1455.                   } else {
  1456.                       sum += width;
  1457.                       _gptr += width;
  1458. ***************
  1459. *** 325,332 ****
  1460.               } else {
  1461.                   size_t r = sgetn((char*)va_arg(ap, char*),
  1462.                            width);
  1463. !                 if (r == 0)
  1464. !                 goto input_failure;
  1465.                   nread += r;
  1466.                   nassigned++;
  1467.               }
  1468. --- 333,340 ----
  1469.               } else {
  1470.                   size_t r = sgetn((char*)va_arg(ap, char*),
  1471.                            width);
  1472. !                 if (r != width)
  1473. !                 goto eof_failure;
  1474.                   nread += r;
  1475.                   nassigned++;
  1476.               }
  1477. ***************
  1478. *** 345,351 ****
  1479.                       break;
  1480.                       if (sgetc() == EOF) {
  1481.                       if (n == 0)
  1482. !                         goto input_failure;
  1483.                       break;
  1484.                       }
  1485.                   }
  1486. --- 353,360 ----
  1487.                       break;
  1488.                       if (sgetc() == EOF) {
  1489.                       if (n == 0)
  1490. !                         goto eof_failure;
  1491. !                     seen_eof++;
  1492.                       break;
  1493.                       }
  1494.                   }
  1495. ***************
  1496. *** 359,365 ****
  1497.                       break;
  1498.                   if (sgetc() == EOF) {
  1499.                       if (p == p0)
  1500. !                     goto input_failure;
  1501.                       break;
  1502.                   }
  1503.                   }
  1504. --- 368,375 ----
  1505.                       break;
  1506.                   if (sgetc() == EOF) {
  1507.                       if (p == p0)
  1508. !                     goto eof_failure;
  1509. !                     seen_eof++;
  1510.                       break;
  1511.                   }
  1512.                   }
  1513. ***************
  1514. *** 382,389 ****
  1515.                       n++, _gptr++;
  1516.                       if (--width == 0)
  1517.                           break;
  1518. !                     if (sgetc() == EOF)
  1519. !                         break;
  1520.                   }
  1521.                   nread += n;
  1522.               } else {
  1523. --- 392,401 ----
  1524.                       n++, _gptr++;
  1525.                       if (--width == 0)
  1526.                           break;
  1527. !                     if (sgetc() == EOF) {
  1528. !                         seen_eof++;
  1529. !                         break;
  1530. !                     }
  1531.                   }
  1532.                   nread += n;
  1533.               } else {
  1534. ***************
  1535. *** 392,399 ****
  1536.                       *p++ = *_gptr++;
  1537.                       if (--width == 0)
  1538.                           break;
  1539. !                     if (sgetc() == EOF)
  1540. !                         break;
  1541.                   }
  1542.                   *p = 0;
  1543.                   nread += p - p0;
  1544. --- 404,413 ----
  1545.                       *p++ = *_gptr++;
  1546.                       if (--width == 0)
  1547.                           break;
  1548. !                     if (sgetc() == EOF) {
  1549. !                         seen_eof++;
  1550. !                         break;
  1551. !                     }
  1552.                   }
  1553.                   *p = 0;
  1554.                   nread += p - p0;
  1555. ***************
  1556. *** 499,507 ****
  1557.                    */
  1558.                   *p++ = c;
  1559.                   _gptr++;
  1560. !                 if (sgetc() == EOF)
  1561. !                     break;        /* EOF */
  1562. !             }
  1563.               /*
  1564.                * If we had only a sign, it is no good; push
  1565.                * back the sign.  If the number ends in `x',
  1566. --- 513,523 ----
  1567.                    */
  1568.                   *p++ = c;
  1569.                   _gptr++;
  1570. !                 if (sgetc() == EOF) {
  1571. !                     seen_eof++;
  1572. !                     break;        /* EOF */
  1573. !                 }
  1574. !                 }
  1575.               /*
  1576.                * If we had only a sign, it is no good; push
  1577.                * back the sign.  If the number ends in `x',
  1578. ***************
  1579. *** 589,596 ****
  1580.           fok:
  1581.                   *p++ = c;
  1582.                   _gptr++;
  1583. !                 if (sgetc() == EOF)
  1584. !                     break;    /* EOF */
  1585.               }
  1586.               /*
  1587.                * If no digits, might be missing exponent digits
  1588. --- 605,614 ----
  1589.           fok:
  1590.                   *p++ = c;
  1591.                   _gptr++;
  1592. !                 if (sgetc() == EOF) {
  1593. !                     seen_eof++;
  1594. !                     break;    /* EOF */
  1595. !                 }
  1596.               }
  1597.               /*
  1598.                * If no digits, might be missing exponent digits
  1599. ***************
  1600. *** 614,622 ****
  1601.               }
  1602.               if ((flags & SUPPRESS) == 0) {
  1603.                   double res;
  1604. - 
  1605.                   *p = 0;
  1606.                   res = atof(buf);
  1607.                   if (flags & LONG)
  1608.                       *va_arg(ap, double *) = res;
  1609.                   else
  1610. --- 632,643 ----
  1611.               }
  1612.               if ((flags & SUPPRESS) == 0) {
  1613.                   double res;
  1614.                   *p = 0;
  1615. + #ifdef USE_DTOA
  1616. +                 res = strtod(buf, NULL);
  1617. + #else
  1618.                   res = atof(buf);
  1619. + #endif
  1620.                   if (flags & LONG)
  1621.                       *va_arg(ap, double *) = res;
  1622.                   else
  1623. ***************
  1624. *** 628,636 ****
  1625.   #endif /* FLOATING_POINT */
  1626.           }
  1627.       }
  1628.   input_failure:
  1629. !     return (nassigned ? nassigned : -1);
  1630.   match_failure:
  1631.       return (nassigned);
  1632.   }
  1633.   
  1634. --- 649,665 ----
  1635.   #endif /* FLOATING_POINT */
  1636.           }
  1637.       }
  1638. + eof_failure:
  1639. +     seen_eof++;
  1640.   input_failure:
  1641. !     if (nassigned == 0)
  1642. !         nassigned = -1;
  1643.   match_failure:
  1644. +     if (state)
  1645. +         *state |= ios::failbit;
  1646. + done:
  1647. +     if (state && seen_eof)
  1648. +         *state |= ios::eofbit;
  1649.       return (nassigned);
  1650.   }
  1651.   
  1652. ***************
  1653. *** 640,646 ****
  1654.    * closing `]'.  The table has a 1 wherever characters should be
  1655.    * considered part of the scanset.
  1656.    */
  1657. ! static u_char *__sccl(register char *tab, register u_char *fmt)
  1658.   {
  1659.       register int c, n, v;
  1660.   
  1661. --- 669,675 ----
  1662.    * closing `]'.  The table has a 1 wherever characters should be
  1663.    * considered part of the scanset.
  1664.    */
  1665. ! static const u_char *__sccl(register char *tab, register const u_char *fmt)
  1666.   {
  1667.       register int c, n, v;
  1668.   
  1669. *** 1.4    1992/06/03 02:12:17
  1670. --- streambu.cc    1992/07/20 22:22:41
  1671. ***************
  1672. *** 193,198 ****
  1673. --- 193,201 ----
  1674.   size_t streambuf::sputn(const char* s, size_t n) // OPTIMIZE THIS!
  1675.   {
  1676.       size_t count = 0;
  1677. + 
  1678. +     if(((long)n) < 0) return 0;
  1679. + 
  1680.       for (; count < n; count++) {
  1681.       if (sputc(*s++) == EOF)
  1682.           break;
  1683. ***************
  1684. *** 224,229 ****
  1685. --- 227,234 ----
  1686.   #else
  1687.   size_t streambuf::sputn(register const char* s, size_t n)
  1688.   {
  1689. +     if (n <= 0)
  1690. +     return 0;
  1691.       register size_t more = n;
  1692.       for (;;) {
  1693.       size_t count = _epptr - _pptr; // Space available.
  1694. ***************
  1695. *** 251,256 ****
  1696. --- 256,262 ----
  1697.       return n - more;
  1698.   }
  1699.   
  1700. + 
  1701.   size_t streambuf::sgetn(char* s, size_t n)
  1702.   {
  1703.       register size_t more = n;
  1704. ***************
  1705. *** 297,302 ****
  1706. --- 303,335 ----
  1707.   }
  1708.   #endif /* atari */
  1709.   
  1710. + int streambuf::padn(char pad, int count)
  1711. + {
  1712. + #define PADSIZE 16
  1713. +     static char const blanks[PADSIZE] =
  1714. +      {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '};
  1715. +     static char const zeroes[PADSIZE] =
  1716. +      {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};
  1717. +     char padbuf[PADSIZE];
  1718. +     const char *padptr;
  1719. +     register int i;
  1720. +     
  1721. +     if (pad == ' ')
  1722. +     padptr = blanks;
  1723. +     else if (pad == '0')
  1724. +     padptr = zeroes;
  1725. +     else {
  1726. +     for (i = PADSIZE; --i >= 0; ) padbuf[i] = pad;
  1727. +     padptr = padbuf;
  1728. +     }
  1729. +     for (i = count; i >= PADSIZE; i -= PADSIZE)
  1730. +     if (sputn(padptr, PADSIZE) != PADSIZE)
  1731. +         return EOF;
  1732. +     if (i > 0 && sputn(padptr, i) != i)
  1733. +     return EOF;
  1734. +     return pad;
  1735. + }
  1736. + 
  1737.   int streambuf::sync()
  1738.   {
  1739.       if (gptr() == egptr() && pptr() == pbase())
  1740. ***************
  1741. *** 430,435 ****
  1742. --- 463,469 ----
  1743.   {
  1744.       if (gptr() <= eback()) return pbackfail(c);
  1745.       gbump(-1);
  1746. +     // Don't write into the get buffer if we don't have to.
  1747.       if (*gptr() != c)
  1748.       *gptr() = c;
  1749.       return (unsigned char)c;
  1750. ***************
  1751. *** 654,659 ****
  1752. --- 688,697 ----
  1753.       return start + count;
  1754.   }
  1755.   
  1756. + 
  1757. + #if defined(linux)
  1758. + #define IO_CLEANUP ;
  1759. + #endif
  1760.   
  1761.   #ifdef IO_CLEANUP
  1762.     IO_CLEANUP
  1763. *** 1.5    1992/06/03 02:12:17
  1764. --- strstrea.cc    1992/07/20 22:22:41
  1765. ***************
  1766. *** 128,134 ****
  1767.   strstreambuf::strstreambuf()
  1768.   {
  1769.       _frozen = 0;
  1770. - //    _flags &= ~ios::dont_close; 
  1771.       _len = 0;
  1772.       _size = 128;
  1773.       _buffer = ALLOC_BUF(_size);
  1774. --- 128,133 ----
  1775. ***************
  1776. *** 140,146 ****
  1777.   strstreambuf::strstreambuf(int initial)
  1778.   {
  1779.       _frozen = 0;
  1780. - //    _flags &= ~ios::dont_close; 
  1781.       _len = 0;
  1782.       if (initial < 16)
  1783.       initial = 16;
  1784. --- 139,144 ----
  1785. ***************
  1786. *** 153,159 ****
  1787.   
  1788.   strstreambuf::strstreambuf(char *ptr, size_t size, char *pstart)
  1789.   {
  1790. - //    _flags &= ~ios::dont_close; 
  1791.       _frozen = 1;
  1792.       if (size == 0)
  1793.       _size = strlen(ptr);
  1794. --- 151,156 ----
  1795. *** 1.3    1992/06/08 20:42:41
  1796. --- timer.cc    1992/07/20 22:22:41
  1797. ***************
  1798. *** 32,39 ****
  1799.   
  1800.   #include <g_config.h>
  1801.   #include <osfcn.h>
  1802. ! #if !defined(_G_HAVE_SYS_RESOURCE) || !defined(RUSAGE_SELF)
  1803.   #define USE_TIMES
  1804.   #include <sys/times.h>
  1805.   #if !defined (HZ) && defined(CLK_TCK)
  1806.   #define HZ CLK_TCK
  1807. --- 32,40 ----
  1808.   
  1809.   #include <g_config.h>
  1810.   #include <osfcn.h>
  1811. ! #if !_G_HAVE_SYS_RESOURCE || !defined(RUSAGE_SELF)
  1812.   #define USE_TIMES
  1813. + #include <sys/param.h>
  1814.   #include <sys/times.h>
  1815.   #if !defined (HZ) && defined(CLK_TCK)
  1816.   #define HZ CLK_TCK
  1817. *** 1.5    1992/06/03 02:12:17
  1818. --- xbitset.cc    1992/07/20 22:22:42
  1819. ***************
  1820. *** 24,30 ****
  1821.   #endif
  1822.   #include <xbitset.h>
  1823.   #include <std.h>
  1824. ! #include <values.h>
  1825.   #include <xobstack.h>
  1826.   #include <xallocri.h>
  1827.   #include <new.h>
  1828. --- 24,30 ----
  1829.   #endif
  1830.   #include <xbitset.h>
  1831.   #include <std.h>
  1832. ! #include <limits.h>
  1833.   #include <xobstack.h>
  1834.   #include <xallocri.h>
  1835.   #include <new.h>
  1836. ***************
  1837. *** 42,48 ****
  1838.   BitSetRep  _nilBitSetRep = { 0, 1, 0, {0} }; // nil BitSets point here
  1839.   
  1840.   #define ONES               ((unsigned short)(~0L))
  1841. ! #define MAXBitSetRep_SIZE  ((1 << (SHORTBITS - 1)) - 1)
  1842.   #define MINBitSetRep_SIZE  16
  1843.   
  1844.   #ifndef MALLOC_MIN_OVERHEAD
  1845. --- 42,48 ----
  1846.   BitSetRep  _nilBitSetRep = { 0, 1, 0, {0} }; // nil BitSets point here
  1847.   
  1848.   #define ONES               ((unsigned short)(~0L))
  1849. ! #define MAXBitSetRep_SIZE  ((1 << (sizeof(short)*CHAR_BIT - 1)) - 1)
  1850.   #define MINBitSetRep_SIZE  16
  1851.   
  1852.   #ifndef MALLOC_MIN_OVERHEAD
  1853. *** 1.4    1992/06/03 02:12:17
  1854. --- xbitstri.cc    1992/07/20 22:22:42
  1855. ***************
  1856. *** 24,30 ****
  1857.   #endif
  1858.   #include <xbitstri.h>
  1859.   #include <std.h>
  1860. ! #include <values.h>
  1861.   #include <xobstack.h>
  1862.   #include <xallocri.h>
  1863.   #include <new.h>
  1864. --- 24,30 ----
  1865.   #endif
  1866.   #include <xbitstri.h>
  1867.   #include <std.h>
  1868. ! #include <limits.h>
  1869.   #include <xobstack.h>
  1870.   #include <xallocri.h>
  1871.   #include <new.h>
  1872. ***************
  1873. *** 43,49 ****
  1874.   BitString _nil_BitString;
  1875.   
  1876.   #define MINBitStrRep_SIZE  8
  1877. ! #define MAXBitStrRep_SIZE  ((1 << (SHORTBITS - 1)) - 1)
  1878.   
  1879.   #ifndef MALLOC_MIN_OVERHEAD
  1880.   #define MALLOC_MIN_OVERHEAD    4
  1881. --- 43,49 ----
  1882.   BitString _nil_BitString;
  1883.   
  1884.   #define MINBitStrRep_SIZE  8
  1885. ! #define MAXBitStrRep_SIZE  ((1 << (sizeof(short)*CHAR_BIT - 1)) - 1)
  1886.   
  1887.   #ifndef MALLOC_MIN_OVERHEAD
  1888.   #define MALLOC_MIN_OVERHEAD    4
  1889. ***************
  1890. *** 148,154 ****
  1891.     if (ss != ds)
  1892.     {
  1893.       int n = (unsigned)(nbits) / BITSTRBITS;
  1894. !     if (n > 0) bcopy((void*)ss, (void*)ds, n * sizeof(short));
  1895.       unsigned short m = ONES << (nbits & (BITSTRBITS - 1));
  1896.       ds[n] = (ss[n] & ~m) | (ds[n] & m);
  1897.     }
  1898. --- 148,154 ----
  1899.     if (ss != ds)
  1900.     {
  1901.       int n = (unsigned)(nbits) / BITSTRBITS;
  1902. !     if (n > 0) memmove((void*)ds, (const void*)ss, n * sizeof(short));
  1903.       unsigned short m = ONES << (nbits & (BITSTRBITS - 1));
  1904.       ds[n] = (ss[n] & ~m) | (ds[n] & m);
  1905.     }
  1906. ***************
  1907. *** 1973,1979 ****
  1908.   
  1909.   void BitString::printon(ostream& os, char f, char t) const
  1910.   {
  1911. -   size_t wrksiz = length() + 2;
  1912.     size_t  xl = rep->len;
  1913.     const unsigned short* ptr = rep->s;
  1914.     register streambuf *sb = os.rdbuf();
  1915. --- 1973,1978 ----
  1916. ***************
  1917. *** 1992,1998 ****
  1918.   {
  1919.     size_t wrksiz = x.length() + 2;
  1920.     char* fmtbase = (char *) _libgxx_fmtq.alloc(wrksiz);
  1921. -   char* fmt = fmtbase;
  1922.     ostrstream stream(fmtbase, wrksiz);
  1923.     
  1924.     x.printon(stream, f, t);
  1925. --- 1991,1996 ----
  1926. *** 1.1    1992/03/22 07:42:32
  1927. --- xgetopt.cc    1992/07/20 22:22:44
  1928. ***************
  1929. *** 19,24 ****
  1930. --- 19,34 ----
  1931.   #ifdef __GNUG__
  1932.   #pragma implementation
  1933.   #endif
  1934. + /* AIX requires the alloca decl to be the first thing in the file. */
  1935. + #ifdef __GNUC__
  1936. + #define alloca __builtin_alloca
  1937. + #elif defined(sparc)
  1938. + #include <alloca.h>
  1939. + #elif defined(_AIX)
  1940. + #pragma alloca
  1941. + #else
  1942. + char *alloca ();
  1943. + #endif
  1944.   #include <xgetopt.h>
  1945.   
  1946.   char* GetOpt::nextchar = 0;
  1947. *** 1.5    1992/06/03 02:12:17
  1948. --- xinteger.cc    1992/07/20 22:22:44
  1949. ***************
  1950. *** 32,38 ****
  1951.   #include <std.h>
  1952.   #include <ctype.h>
  1953.   #include <math.h>
  1954. ! #include <values.h>
  1955.   #include <xobstack.h>
  1956.   #include <xallocri.h>
  1957.   #include <new.h>
  1958. --- 32,38 ----
  1959.   #include <std.h>
  1960.   #include <ctype.h>
  1961.   #include <math.h>
  1962. ! #include <limits.h>
  1963.   #include <xobstack.h>
  1964.   #include <xallocri.h>
  1965.   #include <new.h>
  1966. ***************
  1967. *** 44,50 ****
  1968.    as unsigned shorts is changed in the implementation files.
  1969.   */
  1970.   
  1971. ! #define I_SHIFT         SHORTBITS
  1972.   #define I_RADIX         ((unsigned long)(1L << I_SHIFT))
  1973.   #define I_MAXNUM        ((unsigned long)((I_RADIX - 1)))
  1974.   #define I_MINNUM        ((unsigned long)(I_RADIX >> 1))
  1975. --- 44,50 ----
  1976.    as unsigned shorts is changed in the implementation files.
  1977.   */
  1978.   
  1979. ! #define I_SHIFT         (sizeof(short) * CHAR_BIT)
  1980.   #define I_RADIX         ((unsigned long)(1L << I_SHIFT))
  1981.   #define I_MAXNUM        ((unsigned long)((I_RADIX - 1)))
  1982.   #define I_MINNUM        ((unsigned long)(I_RADIX >> 1))
  1983. ***************
  1984. *** 52,59 ****
  1985.   #define I_NEGATIVE      0
  1986.   
  1987.   /* All routines assume SHORT_PER_LONG > 1 */
  1988. ! #define SHORT_PER_LONG  ((unsigned)(((LONGBITS + SHORTBITS - 1) / SHORTBITS)))
  1989. ! #define CHAR_PER_LONG   ((unsigned)(((LONGBITS + CHARBITS - 1) / CHARBITS)))
  1990.   
  1991.   /*
  1992.     minimum and maximum sizes for an IntRep
  1993. --- 52,59 ----
  1994.   #define I_NEGATIVE      0
  1995.   
  1996.   /* All routines assume SHORT_PER_LONG > 1 */
  1997. ! #define SHORT_PER_LONG  ((unsigned)(((sizeof(long) + sizeof(short) - 1) / sizeof(short))))
  1998. ! #define CHAR_PER_LONG   ((unsigned)sizeof(long))
  1999.   
  2000.   /*
  2001.     minimum and maximum sizes for an IntRep
  2002. ***************
  2003. *** 349,355 ****
  2004.   long Itolong(const IntRep* rep)
  2005.   { 
  2006.     if ((unsigned)(rep->len) > (unsigned)(SHORT_PER_LONG))
  2007. !     return (rep->sgn == I_POSITIVE) ? MAXLONG : MINLONG;
  2008.     else if (rep->len == 0)
  2009.       return 0;
  2010.     else if ((unsigned)(rep->len) < (unsigned)(SHORT_PER_LONG))
  2011. --- 349,355 ----
  2012.   long Itolong(const IntRep* rep)
  2013.   { 
  2014.     if ((unsigned)(rep->len) > (unsigned)(SHORT_PER_LONG))
  2015. !     return (rep->sgn == I_POSITIVE) ? LONG_MAX : LONG_MIN;
  2016.     else if (rep->len == 0)
  2017.       return 0;
  2018.     else if ((unsigned)(rep->len) < (unsigned)(SHORT_PER_LONG))
  2019. ***************
  2020. *** 366,372 ****
  2021.     {
  2022.       unsigned long a = rep->s[SHORT_PER_LONG - 1];
  2023.       if (a >= I_MINNUM)
  2024. !       return (rep->sgn == I_POSITIVE) ? MAXLONG : MINLONG;
  2025.       else
  2026.       {
  2027.         a = up(a) | rep->s[SHORT_PER_LONG - 2];
  2028. --- 366,372 ----
  2029.     {
  2030.       unsigned long a = rep->s[SHORT_PER_LONG - 1];
  2031.       if (a >= I_MINNUM)
  2032. !       return (rep->sgn == I_POSITIVE) ? LONG_MAX : LONG_MIN;
  2033.       else
  2034.       {
  2035.         a = up(a) | rep->s[SHORT_PER_LONG - 2];
  2036. ***************
  2037. *** 381,387 ****
  2038.   }
  2039.   
  2040.   // test whether op long() will work.
  2041. ! // careful about asymmetry between MINLONG & MAXLONG
  2042.   
  2043.   int Iislong(const IntRep* rep)
  2044.   {
  2045. --- 381,387 ----
  2046.   }
  2047.   
  2048.   // test whether op long() will work.
  2049. ! // careful about asymmetry between LONG_MIN & LONG_MAX
  2050.   
  2051.   int Iislong(const IntRep* rep)
  2052.   {
  2053. ***************
  2054. *** 1806,1812 ****
  2055.     return r;
  2056.   }
  2057.   
  2058. ! void setbit(Integer& x, long b)
  2059.   {
  2060.     if (b >= 0)
  2061.     {
  2062. --- 1806,1812 ----
  2063.     return r;
  2064.   }
  2065.   
  2066. ! void (setbit)(Integer& x, long b)
  2067.   {
  2068.     if (b >= 0)
  2069.     {
  2070. *** 1.2    1992/05/31 04:14:02
  2071. --- xstring.cc    1992/07/20 22:22:46
  2072. ***************
  2073. *** 25,31 ****
  2074.   #include <xstring.h>
  2075.   #include <std.h>
  2076.   #include <ctype.h>
  2077. ! #include <values.h>
  2078.   #include <new.h>
  2079.   #include <builtin.h>
  2080.   
  2081. --- 25,31 ----
  2082.   #include <xstring.h>
  2083.   #include <std.h>
  2084.   #include <ctype.h>
  2085. ! #include <limits.h>
  2086.   #include <new.h>
  2087.   #include <builtin.h>
  2088.   
  2089. ***************
  2090. *** 109,115 ****
  2091.   
  2092.   // minimum & maximum representable rep size
  2093.   
  2094. ! #define MAXStrRep_SIZE   ((1 << (SHORTBITS - 1)) - 1)
  2095.   #define MINStrRep_SIZE   16
  2096.   
  2097.   #ifndef MALLOC_MIN_OVERHEAD
  2098. --- 109,115 ----
  2099.   
  2100.   // minimum & maximum representable rep size
  2101.   
  2102. ! #define MAXStrRep_SIZE   ((1 << (sizeof(short) * CHAR_BIT - 1)) - 1)
  2103.   #define MINStrRep_SIZE   16
  2104.   
  2105.   #ifndef MALLOC_MIN_OVERHEAD
  2106.